(function e(t, n, r) {
	function s(o, u) {
		if (!n[o]) {
			if (!t[o]) {
				var a = typeof require == "function" && require;
				if (!u && a) return a(o, !0);
				if (i) return i(o, !0);
				var f = new Error("Cannot find module '" + o + "'");
				throw f.code = "MODULE_NOT_FOUND", f;
			}
			var l = n[o] = {
				exports: {}
			};
			t[o][0].call(l.exports, function (e) {
				var n = t[o][1][e];
				return s(n ? n : e);
			}, l, l.exports, e, t, n, r);
		}
		return n[o].exports;
	}
	var i = typeof require == "function" && require;
	for (var o = 0; o < r.length; o++) s(r[o]);
	return s;
})({
	1: [function (require, module, exports) {
		var process = module.exports = {};
		process.nextTick = function () {
			var canSetImmediate = typeof window !== "undefined" && window.setImmediate;
			var canPost = typeof window !== "undefined" && window.postMessage && window.addEventListener;
			if (canSetImmediate) {
				return function (f) {
					return window.setImmediate(f);
				};
			}
			if (canPost) {
				var queue = [];
				window.addEventListener("message", function (ev) {
					var source = ev.source;
					if ((source === window || source === null) && ev.data === "process-tick") {
						ev.stopPropagation();
						if (queue.length > 0) {
							var fn = queue.shift();
							fn();
						}
					}
				}, true);
				return function nextTick(fn) {
					queue.push(fn);
					window.postMessage("process-tick", "*");
				};
			}
			return function nextTick(fn) {
				setTimeout(fn, 0);
			};
		}();
		process.title = "browser";
		process.browser = true;
		process.env = {};
		process.argv = [];

		function noop() {}
		process.on = noop;
		process.addListener = noop;
		process.once = noop;
		process.off = noop;
		process.removeListener = noop;
		process.removeAllListeners = noop;
		process.emit = noop;
		process.binding = function (name) {
			throw new Error("process.binding is not supported");
		};
		process.cwd = function () {
			return "/";
		};
		process.chdir = function (dir) {
			throw new Error("process.chdir is not supported");
		};
	}, {}],
	2: [function (require, module, exports) {
		"use strict";
		var asap = require("asap");
		module.exports = Promise;

		function Promise(fn) {
			if (typeof this !== "object") throw new TypeError("Promises must be constructed via new");
			if (typeof fn !== "function") throw new TypeError("not a function");
			var state = null;
			var value = null;
			var deferreds = [];
			var self = this;
			this.then = function (onFulfilled, onRejected) {
				return new self.constructor(function (resolve, reject) {
					handle(new Handler(onFulfilled, onRejected, resolve, reject));
				});
			};

			function handle(deferred) {
				if (state === null) {
					deferreds.push(deferred);
					return;
				}
				asap(function () {
					var cb = state ? deferred.onFulfilled : deferred.onRejected;
					if (cb === null) {
						(state ? deferred.resolve : deferred.reject)(value);
						return;
					}
					var ret;
					try {
						ret = cb(value);
					} catch (e) {
						deferred.reject(e);
						return;
					}
					deferred.resolve(ret);
				});
			}

			function resolve(newValue) {
				try {
					if (newValue === self) throw new TypeError("A promise cannot be resolved with itself.");
					if (newValue && (typeof newValue === "object" || typeof newValue === "function")) {
						var then = newValue.then;
						if (typeof then === "function") {
							doResolve(then.bind(newValue), resolve, reject);
							return;
						}
					}
					state = true;
					value = newValue;
					finale();
				} catch (e) {
					reject(e);
				}
			}

			function reject(newValue) {
				state = false;
				value = newValue;
				finale();
			}

			function finale() {
				for (var i = 0, len = deferreds.length; i < len; i++) handle(deferreds[i]);
				deferreds = null;
			}
			doResolve(fn, resolve, reject);
		}

		function Handler(onFulfilled, onRejected, resolve, reject) {
			this.onFulfilled = typeof onFulfilled === "function" ? onFulfilled : null;
			this.onRejected = typeof onRejected === "function" ? onRejected : null;
			this.resolve = resolve;
			this.reject = reject;
		}

		function doResolve(fn, onFulfilled, onRejected) {
			var done = false;
			try {
				fn(function (value) {
					if (done) return;
					done = true;
					onFulfilled(value);
				}, function (reason) {
					if (done) return;
					done = true;
					onRejected(reason);
				});
			} catch (ex) {
				if (done) return;
				done = true;
				onRejected(ex);
			}
		}
	}, {
		asap: 4
	}],
	3: [function (require, module, exports) {
		"use strict";
		var Promise = require("./core.js");
		var asap = require("asap");
		module.exports = Promise;

		function ValuePromise(value) {
			this.then = function (onFulfilled) {
				if (typeof onFulfilled !== "function") return this;
				return new Promise(function (resolve, reject) {
					asap(function () {
						try {
							resolve(onFulfilled(value));
						} catch (ex) {
							reject(ex);
						}
					});
				});
			};
		}
		ValuePromise.prototype = Promise.prototype;
		var TRUE = new ValuePromise(true);
		var FALSE = new ValuePromise(false);
		var NULL = new ValuePromise(null);
		var UNDEFINED = new ValuePromise(undefined);
		var ZERO = new ValuePromise(0);
		var EMPTYSTRING = new ValuePromise("");
		Promise.resolve = function (value) {
			if (value instanceof Promise) return value;
			if (value === null) return NULL;
			if (value === undefined) return UNDEFINED;
			if (value === true) return TRUE;
			if (value === false) return FALSE;
			if (value === 0) return ZERO;
			if (value === "") return EMPTYSTRING;
			if (typeof value === "object" || typeof value === "function") {
				try {
					var then = value.then;
					if (typeof then === "function") {
						return new Promise(then.bind(value));
					}
				} catch (ex) {
					return new Promise(function (resolve, reject) {
						reject(ex);
					});
				}
			}
			return new ValuePromise(value);
		};
		Promise.all = function (arr) {
			var args = Array.prototype.slice.call(arr);
			return new Promise(function (resolve, reject) {
				if (args.length === 0) return resolve([]);
				var remaining = args.length;

				function res(i, val) {
					try {
						if (val && (typeof val === "object" || typeof val === "function")) {
							var then = val.then;
							if (typeof then === "function") {
								then.call(val, function (val) {
									res(i, val);
								}, reject);
								return;
							}
						}
						args[i] = val;
						if (--remaining === 0) {
							resolve(args);
						}
					} catch (ex) {
						reject(ex);
					}
				}
				for (var i = 0; i < args.length; i++) {
					res(i, args[i]);
				}
			});
		};
		Promise.reject = function (value) {
			return new Promise(function (resolve, reject) {
				reject(value);
			});
		};
		Promise.race = function (values) {
			return new Promise(function (resolve, reject) {
				values.forEach(function (value) {
					Promise.resolve(value).then(resolve, reject);
				});
			});
		};
		Promise.prototype["catch"] = function (onRejected) {
			return this.then(null, onRejected);
		};
	}, {
		"./core.js": 2,
		asap: 4
	}],
	4: [function (require, module, exports) {
		(function (process) {
			var head = {
				task: void 0,
				next: null
			};
			var tail = head;
			var flushing = false;
			var requestFlush = void 0;
			var isNodeJS = false;

			function flush() {
				while (head.next) {
					head = head.next;
					var task = head.task;
					head.task = void 0;
					var domain = head.domain;
					if (domain) {
						head.domain = void 0;
						domain.enter();
					}
					try {
						task();
					} catch (e) {
						if (isNodeJS) {
							if (domain) {
								domain.exit();
							}
							setTimeout(flush, 0);
							if (domain) {
								domain.enter();
							}
							throw e;
						} else {
							setTimeout(function () {
								throw e;
							}, 0);
						}
					}
					if (domain) {
						domain.exit();
					}
				}
				flushing = false;
			}
			if (typeof process !== "undefined" && process.nextTick) {
				isNodeJS = true;
				requestFlush = function () {
					process.nextTick(flush);
				};
			} else if (typeof setImmediate === "function") {
				if (typeof window !== "undefined") {
					requestFlush = setImmediate.bind(window, flush);
				} else {
					requestFlush = function () {
						setImmediate(flush);
					};
				}
			} else if (typeof MessageChannel !== "undefined") {
				var channel = new MessageChannel();
				channel.port1.onmessage = flush;
				requestFlush = function () {
					channel.port2.postMessage(0);
				};
			} else {
				requestFlush = function () {
					setTimeout(flush, 0);
				};
			}

			function asap(task) {
				tail = tail.next = {
					task: task,
					domain: isNodeJS && process.domain,
					next: null
				};
				if (!flushing) {
					flushing = true;
					requestFlush();
				}
			}
			module.exports = asap;
		}).call(this, require("_process"));
	}, {
		_process: 1
	}],
	5: [function (require, module, exports) {
		if (typeof Promise.prototype.done !== "function") {
			Promise.prototype.done = function (onFulfilled, onRejected) {
				var self = arguments.length ? this.then.apply(this, arguments) : this;
				self.then(null, function (err) {
					setTimeout(function () {
						throw err;
					}, 0);
				});
			};
		}
	}, {}],
	6: [function (require, module, exports) {
		var asap = require("asap");
		if (typeof Promise === "undefined") {
			Promise = require("./lib/core.js");
			require("./lib/es6-extensions.js");
		}
		require("./polyfill-done.js");
	}, {
		"./lib/core.js": 2,
		"./lib/es6-extensions.js": 3,
		"./polyfill-done.js": 5,
		asap: 4
	}]
}, {}, [6]);
